/**
 * 路由权限控制工具函数
 */

import { 
  ROUTE_PERMISSION_MAP, 
  MENU_PERMISSION_MAP,
  PERMISSION_MODULES,
  PERMISSION_MODULE_NAMES,
  LEVEL_DEFAULT_PERMISSIONS,
  type PermissionModule,
  type UserLevel
} from '../config/permissionConfig';

/**
 * 用户权限数据结构
 */
export interface UserPermissions {
  modules: PermissionModule[];  // 权限模块数组
  level: UserLevel;            // 用户级别
}

/**
 * 解析用户权限字符串到权限对象
 * @param user_perm 权限字符串，支持逗号分隔或JSON格式
 * @param level 用户级别
 * @returns 解析后的权限对象
 */
export const parseUserPermissions = (user_perm: string, level: UserLevel): UserPermissions => {
  let modules: PermissionModule[] = [];

  try {
    // 尝试解析为JSON格式
    if (user_perm.trim().startsWith('[') || user_perm.trim().startsWith('{')) {
      const parsed = JSON.parse(user_perm);
      if (Array.isArray(parsed)) {
        modules = parsed;
      } else if (parsed.modules && Array.isArray(parsed.modules)) {
        modules = parsed.modules;
      }
    } else {
      // 处理逗号分隔的字符串格式
      const permNames = user_perm.split(',').map(p => p.trim()).filter(Boolean);
      modules = permNames.map(name => {
        // 将中文权限名称转换为权限模块标识
        const moduleEntry = Object.entries(PERMISSION_MODULE_NAMES)
          .find(([_, cnName]) => cnName === name);
        return moduleEntry ? moduleEntry[0] as PermissionModule : name as PermissionModule;
      }).filter(module => Object.values(PERMISSION_MODULES).includes(module));
    }
  } catch (error) {
    console.warn('解析用户权限失败，使用默认权限:', error);
    // 解析失败时使用级别对应的默认权限
    modules = [...(LEVEL_DEFAULT_PERMISSIONS[level] || [])];
  }

  // 如果没有解析到权限，使用级别对应的默认权限
  if (modules.length === 0) {
    modules = [...(LEVEL_DEFAULT_PERMISSIONS[level] || [])];
  }

  return {
    modules,
    level
  };
};

/**
 * 将权限对象转换为JSON字符串（用于存储到后端）
 * @param permissions 权限对象
 * @returns JSON字符串
 */
export const stringifyUserPermissions = (permissions: UserPermissions): string => {
  return JSON.stringify({
    modules: permissions.modules,
    level: permissions.level,
    created_at: new Date().toISOString()
  });
};

/**
 * 检查用户是否有访问指定路由的权限
 * @param route 路由路径
 * @param userPermissions 用户权限对象
 * @returns 是否有权限
 */
export const hasRoutePermission = (route: string, userPermissions: UserPermissions): boolean => {
  // 管理员拥有所有权限
  if (userPermissions.level == 1 || userPermissions.level === "1") {
    return true;
  }

  // 获取路由所需的权限
  const requiredPermissions = ROUTE_PERMISSION_MAP[route as keyof typeof ROUTE_PERMISSION_MAP];
  
  // 如果路由不在权限配置中，默认允许访问
  if (!requiredPermissions) {
    return true;
  }

  // 如果路由不需要任何权限，允许访问
  if (requiredPermissions.length === 0) {
    return true;
  }

  // 检查用户是否拥有所需权限中的任意一个
  return requiredPermissions.some(requiredPerm => 
    userPermissions.modules.includes(requiredPerm)
  );
};

/**
 * 检查用户是否有访问指定菜单的权限
 * @param menuKey 菜单标识
 * @param userPermissions 用户权限对象
 * @returns 是否有权限
 */
export const hasMenuPermission = (menuKey: string, userPermissions: UserPermissions): boolean => {
  // 管理员拥有所有权限
  if (userPermissions.level == 1 || userPermissions.level === "1") {
    return true;
  }

  // 获取菜单所需的权限
  const requiredPermissions = MENU_PERMISSION_MAP[menuKey as keyof typeof MENU_PERMISSION_MAP];
  
  // 如果菜单不在权限配置中，默认允许访问
  if (!requiredPermissions) {
    return true;
  }

  // 如果菜单不需要任何权限，允许访问
  if (requiredPermissions.length === 0) {
    return true;
  }

  // 检查用户是否拥有所需权限中的任意一个
  return requiredPermissions.some(requiredPerm => 
    userPermissions.modules.includes(requiredPerm)
  );
};

/**
 * 获取用户有权限访问的路由列表
 * @param userPermissions 用户权限对象
 * @returns 可访问的路由列表
 */
export const getAccessibleRoutes = (userPermissions: UserPermissions): string[] => {
  return Object.keys(ROUTE_PERMISSION_MAP).filter(route => 
    hasRoutePermission(route, userPermissions)
  );
};

/**
 * 获取用户有权限访问的菜单列表
 * @param userPermissions 用户权限对象
 * @returns 可访问的菜单标识列表
 */
export const getAccessibleMenus = (userPermissions: UserPermissions): string[] => {
  return Object.keys(MENU_PERMISSION_MAP).filter(menuKey => 
    hasMenuPermission(menuKey, userPermissions)
  );
};

/**
 * 从localStorage获取当前用户权限
 * @returns 用户权限对象或null
 */
export const getCurrentUserPermissions = (): UserPermissions | null => {
  try {
    const userInfo = localStorage.getItem('user');
    if (!userInfo) {
      return null;
    }

    const user = JSON.parse(userInfo);
    
    // 检查用户级别是否存在
    if (user.level == null || user.level === undefined) {
      return null;
    }

    // 对于管理员（level=1），直接返回所有权限
    if (user.level == 1 || user.level === "1") {
      return {
        modules: Object.values(PERMISSION_MODULES) as PermissionModule[],
        level: 1
      };
    }

    // 对于其他用户，检查user_perm字段
    if (!user.user_perm) {
      // 如果没有user_perm字段，使用默认权限
      return {
        modules: [...(LEVEL_DEFAULT_PERMISSIONS[user.level] || [])],
        level: user.level
      };
    }

    return parseUserPermissions(user.user_perm, user.level);
  } catch (error) {
    console.error('获取用户权限失败:', error);
    return null;
  }
};

/**
 * 检查当前用户是否有访问指定路由的权限
 * @param route 路由路径
 * @returns 是否有权限
 */
export const checkCurrentUserRoutePermission = (route: string): boolean => {
  const permissions = getCurrentUserPermissions();
  if (!permissions) {
    return false;
  }
  return hasRoutePermission(route, permissions);
};

/**
 * 获取权限模块的中文名称
 * @param moduleKey 权限模块标识
 * @returns 中文名称
 */
export const getPermissionModuleName = (moduleKey: PermissionModule): string => {
  return PERMISSION_MODULE_NAMES[moduleKey] || moduleKey;
};

/**
 * 获取所有权限模块选项（用于选择器）
 * @returns 权限选项数组
 */
export const getPermissionOptions = () => {
  return Object.entries(PERMISSION_MODULE_NAMES).map(([key, name]) => ({
    value: key,
    label: name
  }));
};